home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr10 / ehp10.zip / CUR_MAIN.C < prev    next >
C/C++ Source or Header  |  1993-06-19  |  46KB  |  1,323 lines
  1. /******************************************************************************
  2. *
  3. * Modul      : cur_main.c
  4. *
  5. * Funktionen : fatal (Fatale Fehlermeldung ausgeben)
  6. *              beep (Beep auf Lautsprecher ausgeben)
  7. *              flash (Bildschirmrahmen aufblinken lassen)
  8. *              napms (Programm für bestimmte Zeit anhalten)
  9. *              _gyx (Cursor auf Position y/x setzen)
  10. *              show_cursor (Cursor sichtbar machen)
  11. *              hide_cursor (Cursor unsichtbar machen)
  12. *              place_cursor (Cursor im Fenster plazieren)
  13. *              cur_left (Cursor nach links bewegen)
  14. *              cur_right (Cursor nach rechts bewegen)
  15. *              newwin (Neues Fenster anlegen)
  16. *              delwin (Fenster freigeben)
  17. *              mvwin (Fenster bewegen)
  18. *              in_win (Test, ob Punkt in Fenster liegt)
  19. *              calc_overlap (Überlappungsbereich berechnen)
  20. *              overlay (Fensterinhalt für Überlappung ohne Blanks kopieren)
  21. *              overwrite (Fensterinhalt für Überlappung mit Blanks kopieren)
  22. *              mvcur (Cursor an absolute Position bewegen)
  23. *              set_videomode (Anpassung des bildschirmmodus)
  24. *              initscr (Curses initialisieren)
  25. *              endwin (Curses beenden)
  26. *              wnoutrefresh (Window-Image ins VSI kopieren)
  27. *              doupdate (VSI in physikalischen Schirm kopieren)
  28. *              wrefresh (Window-Image ins VSI und VSI auf Schirm kopieren)
  29. *              cur_to_poi (Cursoradresse in Pointer umrechnen)
  30. *              poi_to_cur (Pointer in Cursorposition wandeln)
  31. *              scroll (Fensterinhalt um eine Zeile nach oben bewegen)
  32. *              printw (Text formatiert im Standardfenster ausgeben)
  33. *              scanw (Text formatiert aus Standardfenster einlesen)
  34. *              mvprintw (Text an Position X/Y im Standard-Fenster ausgeben)
  35. *              mvscanw (Daten an bestimmter Stelle im Std.-Fenster einlesen)
  36. *              main (Hauptprogramm)
  37. *
  38. ******************************************************************************/
  39.  
  40. #define cur_main    /* Damit stdscr etc. nicht als extern deklariert werden */
  41.  
  42. #ifdef OS2
  43. #define INCL_DOSPROCESS
  44. #include <os2.h>
  45. #else
  46. #include <dos.h>
  47. #include <process.h>
  48. #endif
  49. #include <stdarg.h>
  50.  
  51. #include "curses.h"
  52.  
  53. void scroll (WINDOW*);
  54.  
  55. struct VioMode { short int length;
  56.          char      mode,
  57.                colours;
  58.          short int x_size_text,
  59.                y_size_text,
  60.                x_size_graph,
  61.                y_size_graph,
  62.                reserved [18]; };
  63.  
  64.  
  65. extern char *reserve_mem();
  66.  
  67. WINDOW *stdscr,           /* Bildschirmgroßes Standardfenster */
  68.        *curscr,           /* Aktueller Bildschirminhalt */
  69.        *last_win;         /* Zuletzt refreshtes Window */
  70. short  int *vsi,          /* Virtueller Bildschirminhalt */
  71.        *PH_SC,            /* Startadresse des Bildschirmram */
  72.        LINES=25,          /* Anzahl der sichbaren Bildschirmzeilen */
  73.        COLS=80;           /* Anzahl der sichbaren Bildschirmspalten */
  74. #ifdef OS2
  75. struct VioMode old_videomode; /* Videomodus beim Aufruf des Editors */
  76. #else
  77. short  old_videomode;
  78. #endif
  79. char   rawflag=FALSE,     /* Flag, ob Eingabe ungepuffert ist */
  80.        echoflag=TRUE,     /* Flag, ob Eingabe angezeigt wird */
  81.        nlflag=TRUE,       /* Flag, ob \r in \n umgewandelt wertden soll */
  82.        start_scan,        /* Cursor Start- und */
  83.        end_scan;          /* Endsscan */
  84.  
  85. /******************************************************************************
  86. *
  87. * Funktion    : Fatale Fehlermeldung ausgeben (fatal)
  88. * -------------
  89. *
  90. * Parameter   : s           :
  91. *                 Typ          : char *
  92. *                 Wertebereich : Pointer auf ASCII-Zeichenkette
  93. *                 Bedeutung    : Auszugebende Fehlermeldung
  94. *
  95. * Bescheibung : Der übergene String s wird ausgegeben, das Programm mit dem
  96. *               Fehlercode 1 abgebrochen.
  97. *
  98. ******************************************************************************/
  99.  
  100. void fatal(s)
  101. char *s;
  102. {
  103.   printf("\nFATAL: %s\nProgramm wird abgebrochen\n",s);
  104.   exit(1);
  105. }
  106.  
  107. /******************************************************************************
  108. *
  109. * Funktion     : Beep auf Lautsprecher ausgeben (beep)
  110. * --------------
  111. *
  112. * Beschreibung : Es werden zwei geschachtelte Schleifen gestartet, in denen
  113. *                ständig das Bit 1 des Port B getoggled wird. Dadurch wird
  114. *                ein Ton erzeugt. Die innere Schleife spezifiziert die
  115. *                Frequenz, die äußere die Dauer des Tones.
  116. *
  117. ******************************************************************************/
  118.  
  119. void beep()
  120. {
  121. #ifdef OS2
  122.   DosBeep (1000, 200);
  123. #else
  124.   char old_portb = inportb(0x61);
  125.   int  i;
  126.  
  127.   outportb(0x61,old_portb | 3); /* GATE 2 setzen */
  128.   outportb(0x43,0xB6);      /* Signal: Counter 2 setzen */
  129.   outportb(0x42,0);         /* Reziprokwert der Frequenz lo */
  130.   outportb(0x42,4);         /*  -------------"---------  hi */
  131.   for (i=0;i<32767;i++);
  132.   outportb(0x61,old_portb);
  133. #endif
  134. }
  135.  
  136. /******************************************************************************
  137. *
  138. * Funktion     : Bildschirmrahmen kurz blinken lassen (flash)
  139. * --------------
  140. *
  141. * Beschreibung : Die Rahmenfarbe wird komplementiert und für kurze Zeit
  142. *                angezeigt. Danach wird wieder die ursprüngliche Farbe
  143. *                restauriert.
  144. *
  145. ******************************************************************************/
  146.  
  147. void flash()
  148. {
  149. #ifdef OS2
  150.   struct VioState { short int length, func, colour; } vs;
  151.   vs.length = 6;
  152.   vs.func   = 1;  /* Funktion Rahmenfarbe ermitteln */
  153.   VioGetState (&vs, 0);
  154.   vs.colour = 255 - vs.colour; /* Farbe invertieren */
  155.   VioSetState (&vs, 0);
  156.   DosSleep (10);
  157.   vs.colour = 255 - vs.colour; /* Alte Farbe wiederherstellen */
  158.   VioSetState (&vs, 0);
  159. #else
  160.   long i;
  161.  
  162.   outportb(0x3D9,15);
  163.   for(i=1;i<8000;i++);
  164.   outportb(0x3D9,0);
  165. #endif
  166. }
  167.  
  168. /******************************************************************************
  169. *
  170. * Funktion     : Programm für bestimmte Zeit anhalten (napms)
  171. * --------------
  172. *
  173. * Parameter    : ms          :
  174. *                  Typ          : int
  175. *                  Wertebereich : 0-32767
  176. *                  Bedeutung    : Zeit in Millisekunden
  177. *
  178. * Ergebnis     :
  179. *                  Typ          : int
  180. *                  Wertebereich : OK
  181. *                  Bedeutung    : Immer OK
  182. *
  183. * Beschreibung : Zwei geschachtelte Schleifen laufen über die angegebene Zeit.
  184. *
  185. ******************************************************************************/
  186.  
  187. int napms(ms)
  188. int ms;
  189. {
  190. #ifdef OS2
  191.   DosSleep (ms);
  192. #else
  193.   int i;
  194.  
  195.   while(ms--)
  196.     for(i=0;i<300;i++);
  197.   return(OK);
  198. #endif
  199. }
  200.  
  201. /******************************************************************************
  202. *
  203. * Funktion     : Cursor auf Position y/x setzen (_gyx)
  204. * --------------
  205. *
  206. * Parameter    : y           :
  207. *                  Typ          : short int
  208. *                  Wertebereich : 0-32767
  209. *                  Bedeutung    : Neue Y-Cursorkoordinate
  210. *
  211. *              : x           :
  212. *                  Typ          : short int
  213. *                  Wertebereich : 0-32767
  214. *                  Bedeutung    : Neue X-Cursorkoordinate
  215. *
  216. * Beschreibung : Der Cursor wird mit dem Interrupt 16 auf die richtige
  217. *                Position gesetzt. Bei OS/2 wird VioSetCurPos verwendet.
  218. *
  219. ******************************************************************************/
  220.  
  221. void _gyx(y,x)
  222. short int y,x;
  223. {
  224. #ifdef OS2
  225.   VioSetCurPos (y, x, 0);
  226. #else
  227.   union REGS r;
  228.  
  229.   r.h.ah = 2;
  230.   r.h.bh = 0;
  231.   r.h.dl = x;
  232.   r.h.dh = y;
  233.   int86(16,&r,&r);
  234. #endif
  235. }
  236.  
  237. /******************************************************************************
  238. *
  239. * Funktion     : Cursor sichtbar machen (show_cursor)
  240. * --------------
  241. *
  242. * Beschreibung : Der Cursor wird mit dem BIOS-Interrupt 16 sichtbar gemacht.
  243. *                Bei OS/2 wird VioGet/SetCurType verwendet.
  244. *
  245. ******************************************************************************/
  246.  
  247. void show_cursor()
  248. {
  249. #ifdef OS2
  250.   struct CurType { short int start_y, end_y, size_x, attrs; } ct;
  251.  
  252.   VioGetCurType (&ct, 0);
  253.   ct.attrs = 0;
  254.   VioSetCurType (&ct, 0);
  255. #else
  256.   union REGS  r;
  257.  
  258.   r.h.ah = 1;
  259.   r.h.ch = start_scan;
  260.   r.h.cl = end_scan;
  261.   int86(16,&r,&r);
  262. #endif
  263. }
  264.  
  265. /******************************************************************************
  266. *
  267. * Funktion     : Cursor unsichtbar machen (hide_cursor)
  268. * --------------
  269. *
  270. * Beschreibung : Der Cursor wird mit dem BIOS-Interrupt 16 unsichtbar gemacht.
  271. *
  272. ******************************************************************************/
  273.  
  274. void hide_cursor()
  275. {
  276. #ifdef OS2
  277.   struct CurType { short int start_y, end_y, size_x, attrs; } ct;
  278.  
  279.   VioGetCurType (&ct, 0);
  280.   ct.attrs = 1;
  281.   VioSetCurType (&ct, 0);
  282. #else
  283.   union REGS r;
  284.  
  285.   r.h.ah = 1;
  286.   r.h.ch = 31;
  287.   int86(16,&r,&r);
  288. #endif
  289. }
  290.  
  291. /******************************************************************************
  292. *
  293. * Funktion     : Cursor im Fenster plazieren (place_cursor)
  294. * --------------
  295. *
  296. * Parameter    : w           :
  297. *                  Typ          : WINDOW *
  298. *                  Wertebereich : Pointer auf WINDOW-Struktur
  299. *                  Bedeutung    : Fenster, in dem der Cursor stehen soll
  300. *
  301. * Beschreibung : Gemäß der in der WINDOW-Struktur gesetzten Cursor-Koordina-
  302. *                ten und Fensterposition wird der Cursor über die Funktion
  303. *                _gyx an die richtige Stelle gesetzt.
  304. *
  305. ******************************************************************************/
  306.  
  307. void place_cursor(w)
  308. WINDOW *w;
  309. {
  310.   _gyx(w->_start_y+w->_cursor_y,w->_start_x+w->_cursor_x);
  311.   show_cursor();
  312. }
  313.  
  314. /******************************************************************************
  315. *
  316. * Funktion     : Cursor nach links bewegen (cur_left)
  317. * --------------
  318. *
  319. * Parameter    : w           :
  320. *                  Typ          : WINDOW *
  321. *                  Wertebereich : Pointer auf WINDOW-Struktur
  322. *                  Bedeutung    : Fenster, dessen Cursor nach links bewegt
  323. *                                 werden soll
  324. *
  325. * Parameter    : anz         :
  326. *                  Typ          : int
  327. *                  Wertebereich : 0-MAXINT
  328. *                  Bedeutung    : Anzahl der Zeichen, um die der Cursor
  329. *                                 nach links bewegt werden soll
  330. *
  331. * Beschreibung : Der Cursor wird anz mal nach links bewegt. Ist er am linken
  332. *                Rand angelangt, so wird er ans Ende der darüberliegenden
  333. *                Zeile gestellt. Ist der Cursor in der oberen linken Fenster-
  334. *                ecke angelangt, so passiert nichts mehr.
  335. *
  336. ******************************************************************************/
  337.  
  338. void cur_left(w,anz)
  339. WINDOW *w;
  340. int anz;
  341. {
  342.   while(anz--)
  343.   {
  344.     if(w->_cursor_x)
  345.       w->_cursor_x--;
  346.     else
  347.       if(w->_cursor_y)
  348.       {
  349.     w->_cursor_x = w->_width_x-1;
  350.     w->_cursor_y--;
  351.       }
  352.   }
  353. }
  354.  
  355. /******************************************************************************
  356. *
  357. * Funktion     : Cursor nach rechts bewegen (cur_right)
  358. * --------------
  359. *
  360. * Parameter    : w           :
  361. *                  Typ          : WINDOW *
  362. *                  Wertebereich : Pointer auf WINDOW-Struktur
  363. *                  Bedeutung    : Fenster, dessen Cursor nach links bewegt
  364. *                                 werden soll
  365. *
  366. * Parameter    : anz         :
  367. *                  Typ          : int
  368. *                  Wertebereich : 0-MAXINT
  369. *                  Bedeutung    : Anzahl der Zeichen, um die der Cursor
  370. *                                 nach rechts bewegt werden soll
  371. *
  372. * Beschreibung : Der Cursor wird anz mal nach rechts bewegt. Ist er am rechten
  373. *                Rand angelangt, so wird er an den Anfang der darunterliegenden
  374. *                Zeile gestellt. Ist der Cursor in der unteren rechten Fenster-
  375. *                ecke angelangt, so wird, falls scroll gesetzt ist, das Fenster
  376. *                gescrollt, ansonsten wird er einfach an den Anfang der
  377. *                letzten Zeile gestellt.
  378. *
  379. ******************************************************************************/
  380.  
  381. void cur_right(w,anz)
  382. WINDOW *w;
  383. int anz;
  384. {
  385.   while(anz--)
  386.   {
  387.     if(w->_cursor_x < w->_width_x-1)
  388.       w->_cursor_x++;
  389.     else
  390.     {
  391.       w->_cursor_x = 0;
  392.       if(w->_cursor_y < w->_width_y-1)
  393.     w->_cursor_y++;
  394.       else
  395.     if(w->_scrflag)
  396.       scroll(w);
  397.     }
  398.   }
  399. }
  400.  
  401. /******************************************************************************
  402. *
  403. * Funktion     : Neues Fenster anlegen (newwin)
  404. * --------------
  405. *
  406. * Parameter    : dy          :
  407. *                  Typ          : short int
  408. *                  Wertebereich : 0-32767
  409. *                  Bedeutung    : Y-Größe des Fensters
  410. *
  411. *              : dx          :
  412. *                  Typ          : short int
  413. *                  Wertebereich : 0-32767
  414. *                  Bedeutung    : X-Größe des Fensters
  415. *
  416. *              : sy          :
  417. *                  Typ          : short int
  418. *                  Wertebereich : 0-32767
  419. *                  Bedeutung    : Y-Startkoordinate des Fensters
  420. *
  421. *              : sx          :
  422. *                  Typ          : short int
  423. *                  Wertebereich : 0-32767
  424. *                  Bedeutung    : X-Startkoordinate des Fensters
  425. *
  426. * Ergebnis     :
  427. *                  Typ          : WINDOW *
  428. *                  Wertebereich : Pointer auf WINDOW-Struktur
  429. *                  Bedeutung    : Pointer auf neu erzeugte WINDOW-Struktur
  430. *
  431. * Beschreibung : Es wird Speicherplatz für eine neue WINDOW-Struktur ange-
  432. *                fordert. Dort werden die Parameter als Position und Größe
  433. *                eingetragen. Es wird Speicherplatz für das Window-Image
  434. *                angefordert. Dieser wird mit dem Standard-Attribut besetzt.
  435. *                Dann werden die Flags (scroll etc.) initialisiert.
  436. *                Der Pointer auf diese Fensterstruktur wird zurückgegeben.
  437. *                Wird bei der Fenstergröße 0 angegeben, so wird der Wert auf
  438. *                das Maximum gesetzt (LINES-sy bzw. COLS-sx).
  439. *
  440. ******************************************************************************/
  441.  
  442. WINDOW *newwin(dy,dx,sy,sx)
  443. short int sx,sy,dx,dy;
  444. {
  445.   WINDOW *w;
  446.  
  447.   w = (WINDOW *) reserve_mem(sizeof(WINDOW));
  448.   if(sx < 0)        sx = 0;
  449.   if(sx > COLS-1)   sx = COLS-1;
  450.   if(sy < 0)        sy = 0;
  451.   if(sy > LINES-1)  sy = LINES-1;
  452.   if(dx < 1)        dx = COLS-sx;
  453.   if(dy < 1)        dy = LINES-sy;
  454.   if(sx+dx > COLS)  dx = COLS-sx;
  455.   if(sy+dy > LINES) dy = LINES-sy;
  456.   w->_start_x = sx;
  457.   w->_start_y = sy;
  458.   w->_width_x = dx;
  459.   w->_width_y = dy;
  460.   w->_cursor_x = w->_cursor_y = 0;
  461.   w->_image = (short int *) reserve_mem(w->_width_y * w->_width_x * sizeof(short int)); /* Speicher für Fensterinhalt */
  462.   werase(w);
  463.   w->_scrflag  = TRUE;  /* Standardmäßig wird das Fenster gescrollt */
  464.   w->_lvokflag = FALSE; /* Cursor ist sichtbar */
  465.   w->_dlyflag  = TRUE;  /* wgetch wartet auf Zeichen */
  466.   w->_tabflag  = TRUE;  /* Tabs werden zu Spaces expandiert */
  467.   w->_attribs  = STD_ATTR; /* Standardattribute für neues Fenster */
  468.   return(w);
  469. }
  470.  
  471. /******************************************************************************
  472. *
  473. * Funktion     : Fenster freigeben (delwin)
  474. * --------------
  475. *
  476. * Parameter    : w           :
  477. *                  Typ          : WINDOW *
  478. *                  Wertebereich : Pointer auf WINDOW-Struktur
  479. *                  Bedeutung    : Freizugebendes Fenster
  480. *
  481. * Beschreibung : Der für das Window-Image und die Window-Struktur reservierte
  482. *                Speicherplatz werden freigegeben.
  483. *
  484. ******************************************************************************/
  485.  
  486. void delwin(w)
  487. WINDOW *w;
  488. {
  489.   if(w)
  490.   {
  491.     free(w->_image);
  492.     free(w);
  493.   }
  494. }
  495.  
  496. /******************************************************************************
  497. *
  498. * Funktion     : Fenster verschieben (mvwin)
  499. * --------------
  500. *
  501. * Parameter    : w           :
  502. *                  Typ          : WINDOW *
  503. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  504. *                  Bedeutung    : Zu verschiebendes Fenster
  505. *
  506. *              : ny          :
  507. *                  Typ          : short int
  508. *                  Wertebereich : 0-32767
  509. *                  Bedeutung    : Neue Y-Startkoordinate des Fensters
  510. *
  511. *              : nx          :
  512. *                  Typ          : short int
  513. *                  Wertebereich : 0-32767
  514. *                  Bedeutung    : Neue X-Startkoordinate des Fensters
  515. *
  516. * Beschreibung : Falls das Fenster an der neuen Position komplett innerhalb
  517. *                des Bildschirms liegt, werden die Startkoordinaten auf
  518. *                die uebergebenen Werte gesetzt.                
  519. *
  520. ******************************************************************************/
  521.  
  522. void mvwin(w,ny,nx)
  523. WINDOW *w;
  524. short int ny,nx;
  525. {
  526.   if(nx >= 0 && ny >= 0
  527.   && nx+w->_width_x <= COLS && ny+w->_width_y <= LINES)
  528.   {
  529.     w->_start_x = nx;
  530.     w->_start_y = ny;
  531.   }
  532. }
  533.  
  534. /******************************************************************************
  535. *
  536. * Funktion     : Testen, ob Punkt in Fenster liegt (in_win)
  537. * --------------
  538. *
  539. * Parameter    : w           :
  540. *                  Typ          : WINDOW *
  541. *                  Wertebereich : Zeiger auf Window-Struktur
  542. *                  Bedeutung    : Fenster, in dem evtl. y/x liegen soll
  543. *
  544. *              : y           :
  545. *                  Typ          : short int
  546. *                  Wertebereich : 0-MAXINT
  547. *                  Bedeutung    : Y-Koordinate des zu testenden Punktes
  548. *
  549. *              : x           :
  550. *                  Typ          : short int
  551. *                  Wertebereich : 0-MAXINT
  552. *                  Bedeutung    : X-Koordinate des zu testenden Punktes
  553. *
  554. * Ergebnis     :
  555. *                  Typ          : int
  556. *                  Wertebereich : TRUE, FALSE
  557. *                  Bedeutung    : TRUE: Punkt innerhalb; FALSE: Punkt außerhalb
  558. *
  559. * Beschreibung : Es wird getestet, ob der Punkt mit den absoluten Koordinaten
  560. *                y und x im Fenster w liegt. Dazu werden die Fenstereckpunkte
  561. *                absolut berechnet.
  562. *
  563. ******************************************************************************/
  564.  
  565. int in_win(w,y,x)
  566. WINDOW *w;
  567. short int y,x;
  568. {
  569.   return (y >= w->_start_y && y < w->_start_y+w->_width_y
  570.        && x >= w->_start_x && x < w->_start_x+w->_width_x);
  571. }
  572.  
  573. /******************************************************************************
  574. *
  575. * Funktion     : Überlappungsbereich zweier Fenster berechnen (calc_overlap)
  576. * --------------
  577. *
  578. * Parameter    : w1          :
  579. *                  Typ          : WINDOW *
  580. *                  Wertebereich : Zeiger auf Window-Struktur
  581. *                  Bedeutung    : 1. Fenster für evtl. Überlappung
  582. *
  583. *              : w2          :
  584. *                  Typ          : WINDOW *
  585. *                  Wertebereich : Zeiger auf Window-Struktur
  586. *                  Bedeutung    : 2. Fenster für evtl. Überlappung
  587. *
  588. *              : l           :
  589. *                  Typ          : short int *
  590. *                  Wertebereich : Pointer auf short int
  591. *                  Bedeutung    : Linker Rand der Überlappung
  592. *
  593. *              : r           :
  594. *                  Typ          : short int *
  595. *                  Wertebereich : Pointer auf short int
  596. *                  Bedeutung    : Rechter Rand der Überlappung
  597. *
  598. *              : o           :
  599. *                  Typ          : short int *
  600. *                  Wertebereich : Pointer auf short int
  601. *                  Bedeutung    : Oberer Rand der Überlappung
  602. *
  603. *              : u           :
  604. *                  Typ          : short int *
  605. *                  Wertebereich : Pointer auf short int
  606. *                  Bedeutung    : Unterer Rand der Überlappung
  607. *
  608. * Ergebnis     :
  609. *                  Typ          : int
  610. *                  Wertebereich : TRUE, FALSE
  611. *                  Bedeutung    : TRUE: Überlappung; FALSE: Keine Übrlp.
  612. *
  613. * Beschreibung : Mit der Funktion in_win wird für jede Ecke der beiden
  614. *                übergebenen Fenster w1 und w2 getestet, ob sie im jeweils
  615. *                anderen Fenster liegen. Falls ja, werden die entsprechenden
  616. *                Eckpunkte gesetzt.
  617. *                Beispiel: Liegt die linke obere Ecke von w2 in w1, dann
  618. *                wird l auf den linken, o auf den oberen Rand von w2 gesetzt.
  619. *
  620. ******************************************************************************/
  621.  
  622. int calc_overlap(w1,w2,l,r,o,u)
  623. WINDOW *w1,*w2;
  624. short int *l,*r,*o,*u;
  625. {
  626.   int ret = FALSE;
  627.  
  628.   /* Zuerst checken, welche Ecken von w1 in w2 liegen */
  629.   if(in_win(w2,w1->_start_y,w1->_start_x))
  630.   { *l = w1->_start_x; *o = w1->_start_y; ret = TRUE; }
  631.   if(in_win(w2,w1->_start_y+w1->_width_y-1,w1->_start_x))
  632.   { *l = w1->_start_x; *u = w1->_start_y+w1->_width_y-1; ret = TRUE; }
  633.   if(in_win(w2,w1->_start_y,w1->_start_x+w1->_width_x-1))
  634.   { *r = w1->_start_x+w1->_width_x-1; *o = w1->_start_y; ret = TRUE; }
  635.   if(in_win(w2,w1->_start_y+w1->_width_y-1,w1->_start_x+w1->_width_x-1))
  636.   { *r = w1->_start_x+w1->_width_x-1; *u = w1->_start_y+w1->_width_y-1; ret = TRUE; }
  637.  
  638.   /* Dann checken, welche Ecken von w2 in w1 liegen */
  639.   if(in_win(w1,w2->_start_y,w2->_start_x))
  640.   { *l = w2->_start_x; *o = w2->_start_y; ret = TRUE; }
  641.   if(in_win(w1,w2->_start_y+w2->_width_y-1,w2->_start_x))
  642.   { *l = w2->_start_x; *u = w2->_start_y+w2->_width_y-1; ret = TRUE; }
  643.   if(in_win(w1,w2->_start_y,w2->_start_x+w2->_width_x-1))
  644.   { *r = w2->_start_x+w2->_width_x-1; *o = w2->_start_y; ret = TRUE; }
  645.   if(in_win(w1,w2->_start_y+w2->_width_y-1,w2->_start_x+w2->_width_x-1))
  646.   { *r = w2->_start_x+w2->_width_x-1; *u = w2->_start_y+w2->_width_y-1; ret = TRUE; }
  647.   return(ret);
  648. }
  649.  
  650. /******************************************************************************
  651. *
  652. * Funktion     : Überlappungsbereich ohne Blanks kopieren (overlay)
  653. * --------------
  654. *
  655. * Parameter    : w1          :
  656. *                  Typ          : WINDOW *
  657. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  658. *                  Bedeutung    : Fenster aus dem kopiert werden soll
  659. *
  660. *              : w2          :
  661. *                  Typ          : WINDOW *
  662. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  663. *                  Bedeutung    : Fennster in das kopiert werden soll
  664. *
  665. * Beschreibung : Zunächst wird mit der Funktion calc_overlap der Überlappungs-
  666. *                bereich berechnet. Ist dieser existent, werden alle Zeichen
  667. *                des Überlappungsbereichs die kein Blank sind, aus Fenster w1
  668. *                nach Fenster w2 kopiert.
  669. *
  670. ******************************************************************************/
  671.  
  672. void overlay(w1,w2)
  673. WINDOW *w1,*w2;
  674. {
  675.   short int l=0,r=0,o=0,u=0, /* Eckpunkte des Überlappungsbereichs */
  676.         zl,              /* Zähler für Durchlaufen des ÜB */
  677.         sk1,sk2,         /* Wie weit Pointer nach Zeilenende
  678.                 erhöht werden müssen */
  679.         *z1,*z2;         /* Pointer in Images */
  680.   char      inhalt;          /* Zu kopierendes Zeichen */
  681.  
  682.   if(calc_overlap(w1,w2,&l,&r,&o,&u)) /* Überlappungsbereich berechnen */
  683.   {
  684.     zl = l;
  685.     /* Skipweite: <Fensterbreite> - <Breite des ÜB> */
  686.     sk1 = w1->_width_x-(r-l)-1;
  687.     sk2 = w2->_width_x-(r-l)-1;
  688.     z1 = w1->_image + w1->_width_x*(o-w1->_start_y) + l-w1->_start_x;
  689.     z2 = w2->_image + w2->_width_x*(o-w2->_start_y) + l-w2->_start_x;
  690.     while (o <= u)
  691.     {
  692.       while (zl <= r)
  693.       {
  694.     if((inhalt = *z1 & 255) != ' ' && inhalt != '\0' && inhalt != '\377')
  695.       *z2++ = *z1++; /* Fensterinhalt von w1 nach w2 kopieren, */
  696.     else             /* falls kein ' ' */
  697.     {
  698.       z1++;   /* Sonst nur die Zeiger erhöhen */
  699.       z2++;
  700.     }
  701.     zl++;         /* Ein Zeichen weiter nach rechts */
  702.       }
  703.       z1 += sk1; /* Alles was nicht zum ÜB gehört überspringen */
  704.       z2 += sk2;
  705.       zl=l; /* An den Anfang der nächsten Zeile des */
  706.       o++; /* Überlappungsbereiches gehen. */
  707.     }
  708.   } /* ende if Überlappung */
  709. }
  710.  
  711. /******************************************************************************
  712. *
  713. * Funktion     : Überlappungsbereich mit Blanks kopieren (overwrite)
  714. * --------------
  715. *
  716. * Parameter    : w1          :
  717. *                  Typ          : WINDOW *
  718. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  719. *                  Bedeutung    : Fenster aus dem kopiert werden soll
  720. *
  721. *              : w2          :
  722. *                  Typ          : WINDOW *
  723. *                  Wertebereich : Zeiger auf WINDOW-Struktur
  724. *                  Bedeutung    : Fennster in das kopiert werden soll
  725. *
  726. * Beschreibung : Zunächst wird mit der Funktion calc_overlap der Überlappungs-
  727. *                bereich berechnet. Ist dieser existent, werden alle Zeichen
  728. *                des Überlappungsbereichs aus Fenster w1 nach Fenster w2
  729. *                kopiert.
  730. *
  731. ******************************************************************************/
  732.  
  733. void overwrite(w1,w2)
  734. WINDOW *w1,*w2;
  735. {
  736.   short int l=0,r=0,o=0,u=0, /* Eckpunkte des Überlappungsbereichs */
  737.         zl,              /* Zähler für Durchlaufen des ÜB */
  738.         sk1,sk2,         /* Wie weit Pointer nach Zeilenende
  739.                 erhöht werden müssen */
  740.         *z1,*z2;         /* Pointer in Images */
  741.  
  742.   if(calc_overlap(w1,w2,&l,&r,&o,&u)) /* Überlappungsbereich berechnen */
  743.   {
  744.     zl = l;
  745.     /* Skipweite: <Fensterbreite> - <Breite des ÜB> */
  746.     sk1 = w1->_width_x-(r-l)-1;
  747.     sk2 = w2->_width_x-(r-l)-1;
  748.     z1 = w1->_image + w1->_width_x*(o-w1->_start_y) + l-w1->_start_x;
  749.     z2 = w2->_image + w2->_width_x*(o-w2->_start_y) + l-w2->_start_x;
  750.     while (o <= u)
  751.     {
  752.       while (zl <= r)
  753.       {
  754.     *z2++ = *z1++; /* Fensterinhalt von w1 nach w2 kopieren, */
  755.     zl++;         /* Ein Zeichen weiter nach rechts */
  756.       }
  757.       z1 += sk1; /* Alles was nicht zum ÜB gehört überspringen */
  758.       z2 += sk2;
  759.       zl=l; /* An den Anfang der nächsten Zeile des */
  760.       o++; /* Überlappungsbereiches gehen. */
  761.     }
  762.   } /* ende if Überlappung */
  763. }
  764.  
  765. /******************************************************************************
  766. *
  767. * Funktion     : Cursor absolut bewegen (mvcur)
  768. * --------------
  769. *
  770. * Parameter    : oy          :
  771. *                  Typ          : short int
  772. *                  Wertebereich : 0-32767
  773. *                  Bedeutung    : Alte Y-Koordinate, wird allerdings
  774. *                                 ignoriert.
  775. *
  776. *              : ox          :
  777. *                  Typ          : short int
  778. *                  Wertebereich : 0-32767
  779. *                  Bedeutung    : Alte X-Koordinate, wird allerdings
  780. *                                 ignoriert
  781. *
  782. *              : ny          :
  783. *                  Typ          : short int
  784. *                  Wertebereich : 0-32767
  785. *                  Bedeutung    : Neue Y-Koordinate
  786. *
  787. *              : nx          :
  788. *                  Typ          : short int
  789. *                  Wertebereich : 0-32767
  790. *                  Bedeutung    : Neue X-Koordinate
  791. *
  792. * Beschreibung : Die Funktion setzt den Hardwarecursor mit der Funktion
  793. *                _gyx auf die gewünschte Position, wobei dazu der
  794. *                Interrupt 16 benutzt wird.
  795. *
  796. ******************************************************************************/
  797.  
  798. void mvcur(oy,ox,ny,nx)
  799. short int oy,ox,ny,nx;
  800. {
  801.   _gyx(ny,nx);
  802. }
  803.  
  804. /******************************************************************************
  805. *
  806. * Funktion     : Videomodus setzen (set_videomode)
  807. * --------------
  808. *
  809. * Beschreibung : Anhand der Werte der beiden Variablen LINES und COLS
  810. *                wird die Nummer des Bildschirmmodus aus einer Tabelle
  811. *                ermittelt. Anschließend wird dieser Modus aktiviert.
  812. *                Die Korrektheit der Koordinaten wird bereits bei der
  813. *                Analyse der Umgebungsvariablen geprüft.
  814. *
  815. ******************************************************************************/
  816.  
  817. void set_videomode()
  818. {
  819. #ifdef OS2
  820.   struct VioMode vm;
  821.  
  822.   vm.length = sizeof (struct VioMode);
  823.   VioGetMode (&vm, 0);
  824.   vm.x_size_text = COLS;
  825.   vm.y_size_text = LINES;
  826.   VioSetMode (&vm, 0);
  827.   VioGetMode (&vm, 0);
  828.   COLS  = vm.x_size_text; /* Falls nicht umgeschaltet werden konnte, */
  829.   LINES = vm.y_size_text; /* aktuelle Fenstergröße ermitteln         */
  830. #else
  831.   int tabelle[9][3] = { { 40,25, 0},   /* Tabelle enthält die Spalten- */
  832.             { 80,25, 2},   /* und die Zeilenzahl sowie     */
  833.             { 80,30,80},   /* die Nummer der unterstützten */
  834.             { 80,43,81},   /* Textmodi.                    */
  835.             { 80,60,82},
  836.             {132,25,87},
  837.             {132,30,88},
  838.             {132,43,89},
  839.             {132,60,90} },
  840.       mode;                     /* Der zu aktivierende Bildschirmmodus */
  841.   union REGS r;               /* Prozessorregister für Video-Interrupt */
  842.  
  843.   for(mode=0;mode<10;mode++)
  844.     if(tabelle[mode][0] == COLS && tabelle[mode][1] == LINES)
  845.     {
  846.       mode = tabelle[mode][2];
  847.       break;
  848.     }
  849.   r.h.ah = 0; /* Funktion setze Video-Modus */
  850.   r.h.al = mode;
  851.   int86(16,&r,&r);  /* Modus mit dem BIOS-Int 16 setzen */
  852. #endif
  853. }
  854.  
  855. #ifdef OS2
  856. /******************************************************************************
  857. *
  858. * Funktion     : Tastatur in Raw-Mode versetzen (set_os2_raw)
  859. * --------------
  860. *
  861. * Beschreibung : Es wird mittels der OS/2 Kernel-Aufrufe KbdGetStatus
  862. *                und KbdSetStatus die Tastatur in den Raw-Mode versetzt.
  863. *                Dadurch können mittels KbdCharIn auch <CTRL>-S und <CTRL>-C
  864. *                erkannt werden.
  865. *
  866. ******************************************************************************/
  867.  
  868. void set_os2_raw (char raw_on)
  869. {
  870.   struct KbdState { unsigned short int length,
  871.                        state,
  872.                        lineend,
  873.                        nls,
  874.                        shift;   } kbst;
  875.  
  876.   KbdGetStatus (&kbst, 0);
  877.   if (raw_on)
  878.     kbst.state = (kbst.state | 4) & ~8;
  879.   else
  880.     kbst.state = (kbst.state | 8) & ~4;
  881.   KbdSetStatus (&kbst, 0);
  882. }
  883.  
  884. void show_kbd_mode()
  885. {
  886.   struct KbdState { unsigned short int length,
  887.                        state,
  888.                        lineend,
  889.                        nls,
  890.                        shift;   } kbst;
  891.  
  892.   KbdGetStatus (&kbst, 0);
  893.   printf("KbdStatus ist %d\n", kbst.state & 12);
  894. }
  895. #endif
  896.  
  897. /******************************************************************************
  898. *
  899. * Funktion     : Curses initialisieren (initscr)
  900. * --------------
  901. *
  902. * Beschreibung : Es wird die Cursorgröße ermittelt und in den globalen
  903. *                Variablen start_scan und end_scan abgelegt. Falls sich
  904. *                die Bildschirmkarte nicht im Monochrommodus befindet,
  905. *                wird der Videomodus an LINES und COLS angepaßt. Sonst wird
  906. *                LINES und COLS an die Größe des monochromen Schirms
  907. *                angepasst.
  908. *                Der Speicherplatz für den Standardbildschirm wird angefor-
  909. *                dert und mit dem Standardattribut besetzt (über die Funktion
  910. *                newwin). Anschließend werden blinkende Zeichen zugelassen.
  911. *
  912. ******************************************************************************/
  913.  
  914. void initscr()
  915. {
  916. #ifdef OS2
  917.   struct VioMode  vm;
  918.   struct VioState { short int length, func, blink; } vs;
  919.  
  920.   vm.length = sizeof (struct VioMode);
  921.   VioGetMode (&vm, 0);
  922.   old_videomode = vm;
  923. #else
  924.   union REGS  r;
  925.  
  926.   r.h.ah = 15; /* Video-Funktion <Get Current VDU Parameters> */
  927.   int86(16,&r,&r);
  928.   old_videomode = r.h.al; /* Aktuellen Video-Modus in old_videomode merken */
  929.   r.h.ah = 3; /* Funktion 3: Cursorpos. und Scan-Start/-Ende ermitteln */
  930.   r.h.bh = 0; /* Page 0 */
  931.   int86(16,&r,&r);
  932.   start_scan = r.h.ch; /* Cursor Start- und Endscan merken */
  933.   end_scan   = r.h.cl;
  934. #endif
  935.   set_videomode(); /* Abhängig von LINES und COLS den Videomodus anpassen */
  936.   last_win = curscr = newwin(LINES,COLS,0,0);
  937.   vsi = curscr->_image;
  938.   stdscr = newwin(LINES,COLS,0,0);
  939. #ifdef OS2
  940.   /* Bildschirm löschen */
  941.   VioWrtNCell ("\0", COLS*LINES, 0, 0, 0);
  942.   vs.func   = 2;
  943.   vs.length = 6;
  944.   vs.blink  = 0; /* Blinkende Zeichen zulassen */
  945.   VioSetState (&vs, 0);
  946. #else
  947.   PH_SC = (old_videomode == 7) ? /* Monochrom-Modus ? Dann VDU-RAM ab B000 */
  948.       (short int*) 0xB0000000 : (short int*) 0xB8000000;
  949.   memcpy(PH_SC,vsi,COLS*LINES*sizeof(short int)); /* Physikalischen Bildschirm löschen */
  950.   outportb(0x3D8,41);  /* Blinkende Zeichen zulassen */
  951. #endif
  952. }
  953.  
  954. /******************************************************************************
  955. *
  956. * Funktion     : Curses beenden (endwin)
  957. * --------------
  958. *
  959. * Beschreibung : Der physikalische Bildschirm wird gelöscht, das stdscr-
  960. *                Fenster wird mit der Funmtion delwin freigegeben.
  961. *                Anschließend wird der Video-Modus aktiviert, der beim Aufruf
  962. *                des Editors aktiv war.
  963. *
  964. ******************************************************************************/
  965.  
  966. void endwin()
  967. {
  968. #ifdef OS2
  969.   /* Bildschirm löschen */
  970.   VioWrtNCell ("\0", COLS*LINES, 0, 0, 0);
  971.   set_os2_raw (FALSE);
  972. #else
  973.   short int  *d;
  974.   int        i;
  975.   union REGS r;
  976.  
  977.   for (d = PH_SC , i=COLS*LINES; i ; i-- , d++)
  978.     *d = STD_ATTR*256; /* Bildschirm löschen */
  979. #endif
  980.   delwin(stdscr);     /* stdscr freigeben */
  981.   delwin(curscr);     /* curscr freigeben */
  982. #ifdef OS2
  983.   VioSetMode (&old_videomode, 0);   /* Videomodus restaurieren */
  984. #else
  985.   r.h.ah = 0; /* Funktion setze Video-Modus */
  986.   r.h.al = old_videomode;
  987.   int86(16,&r,&r);  /* Modus mit dem BIOS-Int 16 setzen */
  988. #endif
  989. }
  990.  
  991. /******************************************************************************
  992. *
  993. * Funktion     : Window-Image ins VSI kopieren (wnoutrefresh)
  994. * --------------
  995. *
  996. * Parameter    : w           :
  997. *                  Typ          : WINDOW *
  998. *                  Wertebereich : Pointer auf WINDOW-Struktur
  999. *                  Bedeutung    : Fenster, dessen Inhalt ins VSI kopiert
  1000. *                                 werden soll.
  1001. *
  1002. * Beschreibung : Der Inhalt des Window-Images wird an der richtigen Stelle
  1003. *                in das virtuelle Screen-Image (VSI) kopiert.
  1004. *
  1005. ******************************************************************************/
  1006.  
  1007. void wnoutrefresh(w)
  1008. WINDOW *w;
  1009. {
  1010.   short int *p_vsi = vsi + COLS*w->_start_y + w->_start_x;
  1011.   short int *p_win = w->_image,y;
  1012.  
  1013.   for(y = w->_width_y;y;y--)
  1014.   {
  1015.     memcpy(p_vsi,p_win,w->_width_x*sizeof(short int)); /* Eine Zeile aus dem Fenster in den virtuellen Bildschirm kopieren */
  1016.     p_vsi += COLS; /* Eine Zeile im virtuellen Schirm nach unten */
  1017.     p_win += w->_width_x; /* Eine Zeile im Fenster nach unten */
  1018.   }
  1019. }
  1020.  
  1021. /******************************************************************************
  1022. *
  1023. * Funktion     : VSI in physikalischen Schirm kopieren (doupdate)
  1024. * --------------
  1025. *
  1026. * Beschreibung : Mit der Funktion memcpy wird das VSI ins physikalische
  1027. *                Bildschirmram kopiert. Anschließend wird der Cursor in das
  1028. *                zuletzt refreshte Fenster gesetzt (last_win).
  1029. *
  1030. ******************************************************************************/
  1031.  
  1032. void doupdate()
  1033. {
  1034. #ifdef OS2
  1035.   VioWrtCellStr (vsi, SZ_SC, 0, 0, 0);
  1036. #else
  1037.   memcpy(PH_SC,vsi,SZ_SC); /* VSI in physikalischen Schirm kopieren */
  1038. #endif
  1039.   if(last_win->_lvokflag)
  1040.     hide_cursor();
  1041.   else
  1042.     place_cursor(last_win);
  1043. }
  1044.  
  1045. /******************************************************************************
  1046. *
  1047. * Funktion     : Window-Image ins VSI und VSI auf Schirm kopieren (wrefresh)
  1048. * --------------
  1049. *
  1050. * Parameter    : w           :
  1051. *                  Typ          : WINDOW *
  1052. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1053. *                  Bedeutung    : Fenster, dessen Inhalt ins VSI soll.
  1054. *
  1055. * Beschreibung : Die globale Variable last_win wird auf w gesetzt. Anschlies-
  1056. *                send wird mit der Funktion wnoutrefresh der Fensterinhalt
  1057. *                in das virtuelle Screen-Image kopiert, danach wird das mo-
  1058. *                difizierte VSI in den Bilschirmspeicher kopiert. Dazu wird
  1059. *                die Funktion doupdate verwendet.
  1060. *
  1061. ******************************************************************************/
  1062.  
  1063. void wrefresh(w)
  1064. WINDOW *w;
  1065. {
  1066. #ifdef CUR_DIRECT
  1067.   WINDOW *old_last_win = last_win;
  1068. #endif
  1069.  
  1070.   last_win = w; /* Dieses Fenster ist das, in dem der Cursor angezeigt wird */
  1071.   wnoutrefresh(w);
  1072. #ifdef CUR_DIRECT
  1073.   if (old_last_win != last_win) /* Muß Fenster erst "nach vorne" gebracht
  1074.                    werden? Dann auch doupdate() aufrufen. */
  1075. #endif
  1076.     doupdate();
  1077. #ifdef CUR_DIRECT
  1078.   else
  1079.     if(last_win->_lvokflag)    /* Cursor hier setzen, da doupdate() */
  1080.       hide_cursor();           /* nicht aufgerufen wurde.           */
  1081.     else
  1082.       place_cursor(last_win);
  1083. #endif
  1084. }
  1085.  
  1086. /******************************************************************************
  1087. *
  1088. * Funktion     : Cursoradresse in Pointer umrechnen (cur_to_poi)
  1089. * --------------
  1090. *
  1091. * Parameter    : w           :
  1092. *                  Typ          : WINDOW *
  1093. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1094. *                  Bedeutung    : Fenster, aus dessen Cursoradresse und
  1095. *                                 Window-Image-Pointer ein Pointer berechnet
  1096. *                                 werden soll, der auf das Zeichen zeigt, auf
  1097. *                                 dem der Cursor steht.
  1098. *
  1099. * Ergebnis     :
  1100. *                  Typ          : short int *
  1101. *                  Wertebereich : Zeiger auf Zeichen im Window-Image
  1102. *                  Bedeutung    : Zeigt auf das Zeichen im Window-Image, auf
  1103. *                                 dem der Cursor des Fensters w steht.
  1104. *
  1105. * Beschreibung : Aus der Startadresse des Window-Images des Fensters w und
  1106. *                der Cursorposition wird die Adresse des Zeichens im WI be-
  1107. *                rechnet, auf dem der Cursor steht. Dieser Zeiger wird
  1108. *                zurückgegeben.
  1109. *
  1110. ******************************************************************************/
  1111.  
  1112. short int *cur_to_poi(w)
  1113. WINDOW *w;
  1114. {
  1115.   return(w->_image + w->_width_x*w->_cursor_y + w->_cursor_x);
  1116. }
  1117.  
  1118. /******************************************************************************
  1119. *
  1120. * Funktion     : Pointer in Cursorposition wandeln (poi_to_cur)
  1121. * --------------
  1122. *
  1123. * Parameter    : w           :
  1124. *                  Typ          : WINDOW *
  1125. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1126. *                  Bedeutung    : Fenster, dessen Cursorkoordinaten angepasst
  1127. *                                 werden sollen und in dessen Window-Image
  1128. *                                 der übergebene Pointer zeigt.
  1129. *
  1130. *              : poi         :
  1131. *                  Typ          : short int *
  1132. *                  Wertebereich : Pointer in Window-Image des Fensters *w
  1133. *                  Bedeutung    : Pointer, der in Cursorkoordinaten umgewan-
  1134. *                                 delt werden soll.
  1135. *
  1136. * Beschreibung : Es werden die Cursorkoordinaten des Fensters w so gesetzt,
  1137. *                daß die korrespondierende Speicherstelle im Window-Image die
  1138. *                ist, auf die der übergebene Pointer zeigt.
  1139. *
  1140. ******************************************************************************/
  1141.  
  1142. void poi_to_cur(w,poi)
  1143. WINDOW *w;
  1144. short int *poi;
  1145. {
  1146.   int diff = poi - w->_image;
  1147.  
  1148.   w->_cursor_y = diff / w->_width_x;
  1149.   w->_cursor_x = diff % w->_width_x;
  1150. }
  1151.  
  1152. /******************************************************************************
  1153. *
  1154. * Funktion     : Fensterinhalt um eine Zeile nach oben bewegen (scroll)
  1155. * --------------
  1156. *
  1157. * Parameter    : w           :
  1158. *                  Typ          : WINDOW *
  1159. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1160. *                  Bedeutung    : Fenster, dessen Inhalt bewegt werden soll
  1161. *
  1162. * Beschreibung : Der Cursor wird in die oberste Zeile des Fensters bewegt.
  1163. *                Dann wird die Funktion wdeleteln aufgerufen, die die oberste
  1164. *                Zeile löscht. Dadurch rücken die darunter gelegenen Zeilen je
  1165. *                um eine Zeile nach oben. Anschliessend wird der Cursor wieder
  1166. *                in seine alte Zeile gesetzt.
  1167. *
  1168. ******************************************************************************/
  1169.  
  1170. void scroll(w)
  1171. WINDOW *w;
  1172. {
  1173.   short int old_y = w->_cursor_y;
  1174.  
  1175.   w->_cursor_y = 0;
  1176.   wdeleteln(w);
  1177.   w->_cursor_y = old_y;
  1178. }
  1179.  
  1180. /******************************************************************************
  1181. *
  1182. * Funktion     : Text formatiert im Standardfenster ausgeben (printw)
  1183. * --------------
  1184. *
  1185. * Parameter    : format      :
  1186. *                  Typ          : char *
  1187. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1188. *                  Bedeutung    : Formatstring (wie bei printf)
  1189. *
  1190. *              : ...         :
  1191. *                  Typ          : Parameterliste
  1192. *                  Wertebereich : ???
  1193. *                  Bedeutung    : Liste auszugebender Werte
  1194. *
  1195. * Beschreibung : Über die Funktion va_start wird ein Zeiger auf die Parame-
  1196. *                terliste gewonnen, der zusammen mit dem Formatstring an
  1197. *                wprintw_body übergeben werden kann. Dort wird der String
  1198. *                "zusammengebastelt" und ausgegeben.
  1199. *
  1200. ******************************************************************************/
  1201.  
  1202. void printw(char *format, ...)
  1203. {
  1204.   va_list param;
  1205.  
  1206.   va_start(param,format);
  1207.   wprintw_body(stdscr,format,param);
  1208.   va_end(param);
  1209. }
  1210.  
  1211. /******************************************************************************
  1212. *
  1213. * Funktion     : Text formatiert aus Standardfenster einlesen (scanw)
  1214. * --------------
  1215. *
  1216. * Parameter    : format      :
  1217. *                  Typ          : char *
  1218. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1219. *                  Bedeutung    : Formatstring (wie bei printf)
  1220. *
  1221. *              : ...         :
  1222. *                  Typ          : Parameterliste
  1223. *                  Wertebereich : ???
  1224. *                  Bedeutung    : Liste zu belegender Variablen
  1225. *
  1226. * Beschreibung : Es wird Über die Funktion va_start ein Zeiger auf die Parame-
  1227. *                terliste gewonnen, der zusammen mit dem Formatstring an
  1228. *                wscanw_body übergeben werden kann.
  1229. *                wscanw_body besetzt die Variablen korrekt.
  1230. *
  1231. ******************************************************************************/
  1232.  
  1233. void scanw(char *format, ...)
  1234. {
  1235.   va_list param;
  1236.  
  1237.   va_start(param,format);
  1238.   wscanw_body(stdscr,format,param);
  1239.   va_end(param);
  1240. }
  1241.  
  1242. /******************************************************************************
  1243. *
  1244. * Funktion     : Text an Position X/Y im Standard-Fenster ausgeben (mvprintw)
  1245. * --------------
  1246. *
  1247. * Parameter    : y           :
  1248. *                  Typ          : short int
  1249. *                  Wertebereich : 0-LINES
  1250. *                  Bedeutung    : Startposition für Ausgabe Y
  1251. *
  1252. *              : x           :
  1253. *                  Typ          : short int
  1254. *                  Wertebereich : 0-COLS
  1255. *                  Bedeutung    : Startposition für Ausgabe X
  1256. *
  1257. *              : format      :
  1258. *                  Typ          : char *
  1259. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1260. *                  Bedeutung    : Formatstring (wie bei printf)
  1261. *
  1262. *              : ...         :
  1263. *                  Typ          : Parameterliste
  1264. *                  Wertebereich : ???
  1265. *                  Bedeutung    : Liste auszugebender Werte
  1266. *
  1267. * Beschreibung : Über va_start wird der Pointer auf den ersten Parameter
  1268. *                ermittelt. Anschließend wird der Cursor an die gewünschte
  1269. *                Stelle bewegt. Dann wird wprintw_body aufgerufen.
  1270. *
  1271. ******************************************************************************/
  1272.  
  1273. void mvprintw(short int y, short int x, char *format, ...)
  1274. {
  1275.   va_list param;
  1276.  
  1277.   va_start(param,format);
  1278.   wmove(stdscr,y,x);
  1279.   wprintw_body(stdscr,format,param);
  1280.   va_end(param);
  1281. }
  1282.  
  1283. /******************************************************************************
  1284. *
  1285. * Funktion     : Daten an bestimmter Stelle im Std.-Fenster einlesen (mvscanw)
  1286. * --------------
  1287. *
  1288. * Parameter    : y           :
  1289. *                  Typ          : short int
  1290. *                  Wertebereich : 0-LINES
  1291. *                  Bedeutung    : Startposition für Eingabe Y
  1292. *
  1293. *              : x           :
  1294. *                  Typ          : short int
  1295. *                  Wertebereich : 0-COLS
  1296. *                  Bedeutung    : Startposition für Eingabe X
  1297. *
  1298. *              : format      :
  1299. *                  Typ          : char *
  1300. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1301. *                  Bedeutung    : Formatstring (wie bei scanf)
  1302. *
  1303. *              : ...         :
  1304. *                  Typ          : Parameterliste
  1305. *                  Wertebereich : ???
  1306. *                  Bedeutung    : Adressen einzulesender Variablen
  1307. *
  1308. * Beschreibung : Der Anfang der Variablenliste wird mit va_start ermittelt.
  1309. *                Dann wird der Cursor an die richtige Stelle bewegt.
  1310. *                Dann wird wscanw_body aufgerufen.
  1311. *
  1312. ******************************************************************************/
  1313.  
  1314. void mvscanw(short int y, short int x, char *format, ...)
  1315. {
  1316.   va_list param;
  1317.  
  1318.   va_start(param,format);
  1319.   wmove(stdscr,y,x);
  1320.   wscanw_body(stdscr,format,param);
  1321.   va_end(param);
  1322. }
  1323.